Course: Core Java Training
Topic: Solving Pattern Printing and Loop-Based Programming Problems
Course Link: Core Java Training Course
Demo Link: Register for a Course Demo
Website: JustAcademy
Pattern printing and loop-based programming problems are important exercises in Core Java. They help beginners understand how loops, conditional statements, nested iterations, variables, and mathematical operations work together to solve programming challenges.
Pattern printing involves displaying characters, numbers, or symbols in a particular arrangement. Loop-based problems also include calculations such as finding factorials, reversing numbers, checking prime numbers, generating multiplication tables, and calculating digit sums.
These exercises develop logical thinking and are frequently used in beginner programming assessments, coding practice, and technical interviews.
for, while, and do-while loops effectively.A loop executes a block of code repeatedly while a specified condition is satisfied or until a defined stopping point is reached.
The for loop is useful when the number of iterations is known in advance.
public class ForLoopExample {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
System.out.println(i);
}
}
}Output:
1
2
3
4
5The while loop checks its condition before executing the loop body. It is useful when the number of repetitions depends on a condition.
public class WhileLoopExample {
public static void main(String[] args) {
int i = 1;
while (i <= 5) {
System.out.println(i);
i++;
}
}
}The do-while loop executes its body at least once because the condition is evaluated after the loop body.
public class DoWhileExample {
public static void main(String[] args) {
int i = 1;
do {
System.out.println(i);
i++;
} while (i <= 5);
}
}| Loop | Condition Checked | Best Use Case |
|---|---|---|
for |
Before each iteration | Known iteration count and index-based patterns |
while |
Before each iteration | Repeating until a condition changes |
do-while |
After each iteration | At least one execution is required |
Most basic patterns are constructed using nested loops. The outer loop controls the rows, while the inner loop controls what is printed within each row.
For example, a square pattern with three rows and three columns requires an outer loop that runs three times and an inner loop that runs three times for each row.
A square star pattern displays the same number of stars in every row.
Expected output:
* * *
* * *
* * *Java program:
public class SquarePattern {
public static void main(String[] args) {
int n = 3;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
System.out.print("* ");
}
System.out.println();
}
}
}Explanation: The outer loop runs three times. For each row, the inner loop prints three stars. After the inner loop finishes, System.out.println() moves the cursor to the next line.
In a right-angled triangle, the number of stars increases by one in each successive row.
Expected output:
*
* *
* * *
* * * *Java program:
public class RightTriangle {
public static void main(String[] args) {
int n = 4;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
System.out.print("* ");
}
System.out.println();
}
}
}How it works:
The inner loop uses j <= i, so its iteration count changes according to the current row number.
An inverted triangle starts with the maximum number of stars and decreases the number in each row.
Expected output:
* * * *
* * *
* *
*Java program:
public class InvertedTriangle {
public static void main(String[] args) {
int n = 4;
for (int i = n; i >= 1; i--) {
for (int j = 1; j <= i; j++) {
System.out.print("* ");
}
System.out.println();
}
}
}Explanation: The outer loop counts downward from n to 1. The inner loop prints as many stars as the current value of i.
A pyramid uses spaces before the stars to align each row around the center.
Expected output:
*
* *
* * *
* * * *Java program:
public class PyramidPattern {
public static void main(String[] args) {
int n = 4;
for (int i = 1; i <= n; i++) {
for (int space = 1; space <= n - i; space++) {
System.out.print(" ");
}
for (int j = 1; j <= i; j++) {
System.out.print("* ");
}
System.out.println();
}
}
}Explanation: The first inner loop prints leading spaces, and the second inner loop prints stars. As the row number increases, the number of leading spaces decreases.
Important: Exact visual alignment depends on the width of the characters and spaces used. For more precise console alignment, use consistent spacing.
Number patterns use integers instead of symbols. In this example, each row prints the numbers from 1 up to the current row number.
Expected output:
1
1 2
1 2 3
1 2 3 4Java program:
public class NumberTriangle {
public static void main(String[] args) {
int n = 4;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + " ");
}
System.out.println();
}
}
}Here, the inner loop variable j is printed instead of printing a fixed symbol. This allows the output to change with every iteration.
A repeated-number pattern prints the current row number multiple times.
Expected output:
1
2 2
3 3 3
4 4 4 4Java program:
public class RepeatedNumberPattern {
public static void main(String[] args) {
int n = 4;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(i + " ");
}
System.out.println();
}
}
}The key difference from the previous example is that the program prints i instead of j. The outer loop controls the repeated value.
Java supports character arithmetic. Incrementing a character such as 'A' produces the next character in the basic Latin alphabet sequence.
Expected output:
A
A B
A B C
A B C DJava program:
public class AlphabetPattern {
public static void main(String[] args) {
int n = 4;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < i; j++) {
char ch = (char) ('A' + j);
System.out.print(ch + " ");
}
System.out.println();
}
}
}Explanation: The expression 'A' + j calculates a character code. Casting the result to char converts it back to a character.
Loop-based programming extends beyond printing patterns. Loops can process numbers digit by digit, perform repeated calculations, and test mathematical conditions.
This problem calculates the sum of all integers from 1 to a given positive integer.
public class NaturalNumberSum {
public static void main(String[] args) {
int n = 10;
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += i;
}
System.out.println("Sum = " + sum);
}
}Output: Sum = 55
The variable sum accumulates the value of each number as the loop progresses.
The factorial of a non-negative integer is the product of all positive integers up to that number. By definition, 0! = 1.
public class FactorialExample {
public static void main(String[] args) {
int n = 5;
long factorial = 1;
if (n < 0) {
System.out.println("Factorial is not defined for negative integers.");
return;
}
for (int i = 1; i <= n; i++) {
factorial *= i;
}
System.out.println("Factorial = " + factorial);
}
}Output: Factorial = 120
Using long provides a larger range than int, but even long overflows for sufficiently large factorials. Validate input limits when developing a reusable solution.
A multiplication table can be generated by multiplying a fixed number by each integer in a chosen range.
public class MultiplicationTable {
public static void main(String[] args) {
int number = 7;
for (int i = 1; i <= 10; i++) {
System.out.println(number + " x " + i + " = " + (number * i));
}
}
}This example prints the multiplication table of 7 from 1 to 10.
Reversing a number involves repeatedly extracting its last digit and adding that digit to a new number.
public class ReverseNumber {
public static void main(String[] args) {
int number = 1234;
int reversed = 0;
while (number != 0) {
int digit = number % 10;
reversed = reversed * 10 + digit;
number /= 10;
}
System.out.println("Reversed number = " + reversed);
}
}Output: Reversed number = 4321
The modulo operator % extracts the last digit, while integer division by 10 removes that digit. This basic example assumes a non-negative input and a result that fits within the int range.
public class SumOfDigits {
public static void main(String[] args) {
int number = 582;
int sum = 0;
while (number != 0) {
sum += number % 10;
number /= 10;
}
System.out.println("Digit sum = " + sum);
}
}Output: Digit sum = 15
For the number 582, the digits are 5, 8, and 2. Their sum is 15. For a reusable method, consider handling negative values and zero explicitly.
A prime number is an integer greater than 1 that has exactly two positive divisors: 1 and itself.
public class PrimeNumber {
public static void main(String[] args) {
int number = 17;
boolean isPrime = number > 1;
for (int i = 2; i <= number / i && isPrime; i++) {
if (number % i == 0) {
isPrime = false;
}
}
if (isPrime) {
System.out.println(number + " is prime.");
} else {
System.out.println(number + " is not prime.");
}
}
}Output: 17 is prime.
The loop tests possible divisors only up to the square root of the number. The condition i <= number / i avoids multiplication overflow that could occur with i * i for very large integers.
Conditions allow programs to make decisions during repeated execution. The if, else if, and else statements are often used with loops to print selected values or process numbers according to a rule.
Example: Print even numbers from 1 to 20.
public class EvenNumbers {
public static void main(String[] args) {
for (int i = 1; i <= 20; i++) {
if (i % 2 == 0) {
System.out.print(i + " ");
}
}
}
}Output: 2 4 6 8 10 12 14 16 18 20
The condition i % 2 == 0 checks whether the number is divisible by 2 without a remainder.
The break statement immediately exits the nearest enclosing loop.
public class BreakExample {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i == 6) {
break;
}
System.out.print(i + " ");
}
}
}Output: 1 2 3 4 5
The continue statement skips the remaining statements in the current iteration and proceeds to the next iteration.
public class ContinueExample {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i % 2 == 0) {
continue;
}
System.out.print(i + " ");
}
}
}Output: 1 3 5 7 9
Dry running means manually tracing a program to understand how its variables change during execution.
Consider the following code:
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + " ");
}
System.out.println();
}Iteration trace:
| Outer Loop (i) | Inner Loop Values (j) | Output Row |
|---|---|---|
| 1 | 1 | 1 |
| 2 | 1, 2 | 1 2 |
| 3 | 1, 2, 3 | 1 2 3 |
Dry running makes it easier to identify incorrect loop conditions, missing increments, and unexpected output.
| Mistake | Why It Happens | Solution |
|---|---|---|
| Infinite loop | The loop variable does not move toward the stopping condition. | Check the increment, decrement, and condition. |
| Incorrect number of rows | The outer loop uses the wrong starting or ending value. | Verify the row count and boundary conditions. |
| Incorrect number of symbols | The inner loop condition does not match the pattern rule. | Trace the inner loop for each row. |
| Unexpected spaces | Leading spaces or separators are printed incorrectly. | Separate the spacing logic from the symbol logic. |
| Wrong number in a pattern | The program prints the wrong loop variable. | Check whether the pattern needs the row index or column index. |
| Incorrect factorial result | The accumulator starts at zero instead of one. | Initialize the product accumulator to 1. |
| Incorrect digit calculation | Modulo and integer division are used incorrectly. | Use % 10 to extract the last digit and /= 10 to remove it. |
| Integer overflow | A calculation exceeds the numeric type's range. | Choose an appropriate type and validate limits. |
Time complexity describes how the amount of work performed by an algorithm grows as the input size increases.
| Loop Structure | Typical Complexity | Example |
|---|---|---|
| One loop from 1 to n | O(n) | Sum of natural numbers |
| Two independent nested loops, each running n times | O(n²) | Printing an n-by-n square |
| Nested triangle loops with row lengths from 1 to n | O(n²) | Printing a right-angled triangle |
| Repeatedly divide a positive number by 10 | O(log n) | Processing decimal digits |
These are typical classifications. The actual complexity depends on the loop bounds and operations performed. For example, a square pattern with n rows and n columns prints n² symbols, so the output itself requires quadratic work.
Try solving the following problems without looking at a completed solution first.
Create a console application that allows users to choose a pattern or mathematical operation. This project combines loops, conditional statements, methods, and basic input handling.
Suggested features:
switch statement to select the operation.Sample menu:
1. Print Star Triangle
2. Print Number Triangle
3. Calculate Factorial
4. Calculate Digit Sum
5. Print Multiplication Table
0. Exit
Enter your choice:Project learning outcome: This project demonstrates how loop logic can be organized into a small, reusable Java application rather than isolated code examples.
Answer: Pattern printing is the process of displaying symbols, numbers, or characters in a structured arrangement using loops and, when required, conditional statements.
Answer: Nested loops allow one loop to control rows while another controls the items printed within each row.
Answer: print() displays content without automatically moving to a new line. println() displays content and then moves to a new line.
Answer: Use an outer loop for the rows and an inner loop whose upper bound is the current row number.
Answer: Start the outer loop at the maximum row count and decrease the number of symbols printed in each successive row.
Answer: An infinite loop occurs when the termination condition never becomes false, often because a counter is not updated correctly.
Answer: Initialize a product variable to 1 and multiply it by each integer from 1 through n. Handle negative inputs separately.
Answer: Extract the last digit using modulo 10, append it to a result multiplied by 10, and remove the digit using integer division by 10.
Answer: The time complexity is typically O(n²), because the inner loop executes n times for each of the n outer-loop iterations.
Answer: Verify the row and column counts, check the loop boundaries, inspect spacing logic, and manually trace a few iterations.
for, while, and do-while loops.System.out.print() for items on the same line and System.out.println() to move to the next line.Solving pattern printing and loop-based programming problems builds a strong foundation in Core Java. These exercises teach how to control repetition, organize nested loops, work with numbers and characters, and combine loops with conditional statements.
Consistent practice is the best way to improve. Start with simple square and triangle patterns, progress to number and alphabet patterns, and then solve mathematical problems such as factorials, prime numbers, and digit operations. Once these concepts become comfortable, combine them into small menu-driven Java projects.
To explore structured Core Java learning, visit JustAcademy's Core Java Training Course. You can also register for a course demo or visit the JustAcademy website.
